﻿//using System;
//using System.Configuration;
//using System.Diagnostics;
//using System.Linq;
//using System.Net;
//using System.Text;
//using System.IO;
//using System.Xml;
//using System.Xml.Serialization;
//using System.IO.Compression;
//using com.gmccadc.Utility;
//using DataModel;
//using ICSharpCode.SharpZipLib.Checksums;
//using ICSharpCode.SharpZipLib.Zip;
//using System.Collections.Generic;
//using InterfaceBLL.Common;
//using InterfaceDAL;
//using Microsoft.Win32;
//using Openlab.Common;
//using SevenZip;

//namespace InterfaceBLL
//{
//    public class Services
//    {

//        /// <summary>
//        /// XML序列化对象
//        /// </summary>
//        /// <param name="Instance">object that would be converted into xml</param>
//        /// <returns></returns>
//        public static string ObjectToXML(Object Instance)
//        {
//            //Instance = null;
//            MemoryStream stream = null;
//            TextWriter writer = null;
//            Encoding defualtEncoding = Encoding.GetEncoding("gb2312");

//            try
//            {
//                stream = new MemoryStream(); // read xml in memory
//                writer = new StreamWriter(stream, defualtEncoding);

//                // get serialise object
//                //XmlSerializer serializer = new XmlSerializer(typeof(Emp),"");
//                XmlSerializer serializer = new XmlSerializer(Instance.GetType());

//                XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
//                xsn.Add(string.Empty, string.Empty);

//                serializer.Serialize(writer, Instance, xsn); // read object




//                int count = (int) stream.Length; // saves object in memory stream
//                byte[] arr = new byte[count];
//                stream.Seek(0, SeekOrigin.Begin);
//                // copy stream contents in byte array
//                stream.Read(arr, 0, count);

//                //    UTF8Encoding utf = new UTF8Encoding();

//                string strLin = defualtEncoding.GetString(arr).Trim();
//                ;

//                //  string output = EncodingConvert(defualtEncoding, new UTF8Encoding(false), strLin);

//                return strLin.Replace("<?xml version=\"1.0\" encoding=\"gb2312\"?>",
//                                      "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
//            }
//            catch (Exception ex)
//            {
//                throw new Exception(ex.ToString());
//            }
//            finally
//            {
//                if (stream != null && stream.Length > 0)
//                {
//                    stream.Close();
//                }
//                if (writer != null)
//                {
//                    writer.Close();
//                }
//            }
//        }

//        /// <summary>
//        /// POST数据
//        /// </summary>
//        /// <param name="url"></param>
//        /// <param name="reqXML"></param>
//        /// <returns></returns>
//        public static string PostXML(string url, string reqXML)
//        {
//            HttpWebRequest req =
//                (HttpWebRequest) WebRequest.Create(url);
//            req.Method = "POST";
//            req.KeepAlive = true;
//            req.ContentType = "application/x-www-form-urlencoded;charset=UTF-8";

//            byte[] postData = Encoding.UTF8.GetBytes(reqXML);
//            Stream reqStream = req.GetRequestStream();
//            reqStream.Write(postData, 0, postData.Length);
//            reqStream.Close();

//            HttpWebResponse rsp = (HttpWebResponse) req.GetResponse();
//            Encoding encoding = Encoding.GetEncoding(rsp.CharacterSet);
//            return GetResponseAsString(rsp, encoding);
//        }



//        /// <summary>
//        /// 把响应流转换为文本。
//        /// </summary>
//        /// <param name="rsp">响应流对象</param>
//        /// <param name="encoding">编码方式</param>
//        /// <returns>响应文本</returns>
//        private static string GetResponseAsString(HttpWebResponse rsp, Encoding encoding)
//        {
//            StringBuilder result = new StringBuilder();
//            Stream stream = null;
//            StreamReader reader = null;

//            try
//            {
//                // 以字符流的方式读取HTTP响应
//                stream = rsp.GetResponseStream();
//                reader = new StreamReader(stream, encoding);

//                // 每次读取不大于256个字符，并写入字符串
//                var buffer = new char[256];
//                int readBytes;
//                while ((readBytes = reader.Read(buffer, 0, buffer.Length)) > 0)
//                {
//                    result.Append(buffer, 0, readBytes);
//                }
//            }
//            finally
//            {
//                // 释放资源
//                if (reader != null) reader.Close();
//                if (stream != null) stream.Close();
//                if (rsp != null) rsp.Close();
//            }

//            return result.ToString();
//        }

//        /// <summary>
//        /// 序列化对象保存到XML文件
//        /// </summary>
//        /// <param name="Instance">object that would be converted into xml</param>
//        /// <param name="fileName">保存的文件名</param>
//        /// <returns></returns>
//        public static void ObjectToFile(Object Instance, string fileName)
//        {
//            StreamWriter writer = new StreamWriter(fileName);
//            try
//            {
//                XmlSerializer serializer = new XmlSerializer(Instance.GetType());
//                serializer.Serialize(writer, Instance);
//            }
//            catch (Exception ex)
//            {
//            }
//            finally
//            {
//                if (writer != null)
//                {
//                    writer.Close();
//                }
//            }
//        }

//        /// <summary>
//        /// 从文件反序列化为对象
//        /// </summary>
//        /// <param name="xmlFilePath"></param>
//        /// <returns></returns>
//        public static object FileToObject(string xmlFilePath, Type t)
//        {
//            XmlSerializer ser = null;
//            FileStream readFs = null;
//            Object o = null;
//            try
//            {
//                ser = new XmlSerializer(t);
//                readFs = File.OpenRead(xmlFilePath);
//                XmlTextReader reader = new XmlTextReader(readFs);
//                o = ser.Deserialize(reader);
//            }
//            catch (Exception ex)
//            {
//                InterfaceLog.InterfaceERROR("反序列化对象过程中出错！", ex);
//            }
//            finally
//            {
//                if (readFs != null) readFs.Close();
//            }
//            return o;
//        }

//        /// <summary>
//        /// 从Stream反序列化为对象
//        /// </summary>
//        /// <param name="xmlFilePath"></param>
//        /// <returns></returns>
//        public static object StreamToObject(Stream stream, Type t)
//        {
//            XmlSerializer ser = null;
//            Object o = null;
//            try
//            {
//                ser = new XmlSerializer(t);
//                XmlTextReader reader = new XmlTextReader(stream);
//                o = ser.Deserialize(reader);
//            }
//            catch (Exception ex)
//            {
//                InterfaceLog.InterfaceERROR("反序列化对象过程中出错！", ex);
//            }
//            return o;
//        }

//        public static byte[] StreamToBytes(Stream stream)
//        {
//            byte[] bytes = new byte[stream.Length];
//            stream.Read(bytes, 0, bytes.Length);

//            // 设置当前流的位置为流的开始
//            stream.Seek(0, SeekOrigin.Begin);
//            return bytes;
//        }

//        public static Stream ObjectToStream(Object instance)
//        {
//            return ObjectToStream(instance, new UTF8Encoding(false));
//        }

//        public static Stream ObjectToStream(Object instance, Encoding encoding)
//        {
//            string xml = ObjectToXML(instance);
//            Stream s = new MemoryStream(encoding.GetBytes(xml));
//            return s;
//        }

//        public static Stream StringToStream(string str, Encoding encoding)
//        {
//            return new MemoryStream(encoding.GetBytes(str));
//        }

//        public static Stream StringToStream(string str)
//        {
//            return StringToStream(str, new UTF8Encoding(false));
//        }

//        public static string StreamToString(MemoryStream stream)
//        {
//            StreamReader reader = new StreamReader(stream, Encoding.Default);
//            String temp = reader.ReadToEnd();
//            return temp;
//        }

//        public static string StreamToString(MemoryStream stream, Encoding encoding)
//        {
//            StreamReader reader = new StreamReader(stream, encoding);
//            String temp = reader.ReadToEnd();
//            return temp;
//        }

//        /// <summary>
//        /// 将XML字符串反序列化为一个对象
//        /// </summary>
//        /// <typeparam name="T">对象的类型</typeparam>
//        /// <param name="xml">需要反序列化的XML字符串</param>
//        /// <returns>对象的实例</returns>
//        public static T XMLToObject<T>(string xml)
//        {
//            return (T) XMLToObject(xml, typeof (T));
//        }

//        public static string EncodingConvert(Encoding srcEncoding, Encoding dstEncoding, string src)
//        {
//            //string unicodeString = "This string contains the unicode character Pi(\u03a0)";

//            //// Create two different encodings. 
//            //Encoding ascii = Encoding.ASCII;
//            //Encoding unicode = Encoding.Unicode;

//            // Convert the string into a byte[]. 
//            byte[] unicodeBytes = srcEncoding.GetBytes(src);

//            // Perform the conversion from one encoding to the other. 
//            byte[] asciiBytes = Encoding.Convert(srcEncoding, dstEncoding, unicodeBytes);

//            // Convert the new byte[] into a char[] and then into a string. 
//            // This is a slightly different approach to converting to illustrate 
//            // the use of GetCharCount/GetChars. 
//            char[] dstChars = new char[dstEncoding.GetCharCount(asciiBytes, 0, asciiBytes.Length)];
//            dstEncoding.GetChars(asciiBytes, 0, asciiBytes.Length, dstChars, 0);
//            string dstString = new string(dstChars);
//            return dstString;
//        }

//        /// <summary>
//        /// 反序列化XML字符串
//        /// </summary>
//        /// <param name="xml">xml data of employee</param>
//        /// <returns></returns>
//        public static object XMLToObject(string xml, Type t)
//        {

//            StringReader stream = null;
//            XmlTextReader reader = null;
//            Object o = null;
//            try
//            {
//                XmlSerializer serializer = new XmlSerializer(t);
//                stream = new StringReader(xml); // read xml data
//                reader = new XmlTextReader(stream); // create reader

//                o = serializer.Deserialize(reader);
//            }
//            catch (Exception ex)
//            {
//                InterfaceLog.InterfaceERROR("反序列化对象过程中出错！", ex);
//            }
//            finally
//            {
//                if (stream != null)
//                {
//                    stream.Close();
//                }
//                if (reader != null)
//                {
//                    reader.Close();
//                }
//            }
//            return o;
//        }

//        public static string SIMonitorXmlFormat(string src)
//        {
//            string ss = src;
//            string Split = "\n";
//            string strSplit = "\r";
//            string strSplit0 = "\r\n";
//            string strSplit1 = "q1:";
//            string strSplit2 = "xmlns:q1=\"http://tempuri.org/XMLSchema.xsd\"";
//            string strSplit3 = "BOSSProvisioningRequest";
//            string strSplit4 = "BossPrdStateModifyRequest";
//            string strSplit5 = "ServiceStateModifyRequest";
//            string strSplit6 = "xmlns:q1=\" \"";

//            //ss = ((ss.Substring(40, ss.Length - 40)).Replace(strSplit, "")).ToString();
//            string startXml = "<?";
//            string endXml = "?>";
//            int startPos = ss.IndexOf(startXml);
//            int endPos = ss.IndexOf(endXml);
//            if (!(startPos == -1 || endPos == -1))
//            {
//                ss = ss.Remove(startPos, endPos - startPos + endXml.Length);
//            }

//            ss = (ss.Replace(strSplit2, "")).ToString();
//            ss = (ss.Replace(strSplit1, "")).ToString();
//            ss = (ss.Replace(strSplit3, "")).ToString();
//            ss = (ss.Replace(strSplit4, "")).ToString();
//            ss = (ss.Replace(strSplit5, "")).ToString();
//            ss = (ss.Replace(strSplit6, "")).ToString();
//            ss = (ss.Replace(Split, "")).ToString();
//            ss = (ss.Replace(strSplit, "")).ToString();
//            ss = (ss.Replace(strSplit0, "")).ToString();

//            return ss;
//        }


//        /// <summary>
//        /// 格式化字符串
//        /// </summary>
//        /// <param name="ss"></param>
//        /// <returns></returns>
//        public static string strFormat(string ss)
//        {
//            return SIMonitorXmlFormat(ss);
//            ////<?xml version='1.0' encoding='utf-8' ?>
//            //string strSplit = "\r\n";
//            //string strSplit1 = "q1:";
//            //string strSplit2 = "xmlns:q1=\"http://tempuri.org/XMLSchema.xsd\"";
//            //string strSplit3 = "BOSSProvisioningRequest";
//            //string strSplit4 = "BossPrdStateModifyRequest";
//            //string strSplit5 = "ServiceStateModifyRequest";            
//            ////string strSplit6 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";

//            ////ss = ((ss.Substring(40, ss.Length - 40)).Replace(strSplit, "")).ToString();
//            //string startXml = "<?";
//            //string endXml = "?>";
//            //int startPos = ss.IndexOf(startXml);
//            //int endPos = ss.IndexOf(endXml);
//            //if (!(startPos == -1 || endPos == -1))
//            //{
//            //    ss = ss.Remove(startPos, endPos - startPos + endXml.Length);
//            //}
//            //ss = (ss.Replace(strSplit2, "")).ToString();
//            //ss = (ss.Replace(strSplit1, "")).ToString();
//            //ss = (ss.Replace(strSplit3, "")).ToString();
//            //ss = (ss.Replace(strSplit4, "")).ToString();
//            //ss = (ss.Replace(strSplit5, "")).ToString();
//            ////ss = (ss.Replace(strSplit6, "")).ToString();
//            //return ss;
//        }

//        /// <summary>
//        /// 格式化字符串
//        /// </summary>
//        /// <param name="ss"></param>
//        /// <returns></returns>
//        public static string Format(string ss)
//        {
//            string Split = "\n";
//            string strSplit = "\r";
//            string strSplit1 = "q1:";
//            string strSplit2 = "xmlns:q1=\"http://tempuri.org/XMLSchema.xsd\"";
//            string strSplit3 = "SISyncRequest";
//            string strSplit4 = "SIBusiness";
//            string strSplit5 = "SICloseRequest";
//            string strSplit6 = "AssessResultSyncRequest";
//            string strSplit7 = "BlacklistQueryRequest";
//            string strSplit8 = "SIBalanceQueryRequest";
//            string strSplit9 = "PowerRequest";
//            string strSplit10 = "RelationRequest";
//            string strSplit11 = "SIBalanceSyncRequest";
//            string strSplit12 = "BossResApplyRequest";
//            string strSplit13 = "SICloseRequest";

//            ss = (ss.Replace(Split, "")).ToString();
//            ss = (ss.Replace(strSplit, "")).ToString();
//            ss = (ss.Replace(strSplit2, "")).ToString();
//            ss = (ss.Replace(strSplit1, "")).ToString();
//            ss = (ss.Replace(strSplit3, "")).ToString();
//            ss = (ss.Replace(strSplit4, "")).ToString();
//            ss = (ss.Replace(strSplit5, "")).ToString();
//            ss = (ss.Replace(strSplit6, "")).ToString();
//            ss = (ss.Replace(strSplit7, "")).ToString();
//            ss = (ss.Replace(strSplit8, "")).ToString();
//            ss = (ss.Replace(strSplit9, "")).ToString();
//            ss = (ss.Replace(strSplit10, "")).ToString();
//            ss = (ss.Replace(strSplit11, "")).ToString();
//            ss = (ss.Replace(strSplit12, "")).ToString();
//            ss = (ss.Replace(strSplit13, "")).ToString();

//            return ss.Replace("  ", "").ToString();
//        }



//        /// <summary>
//        /// 构造对象的XML信息,用于日志记录
//        /// </summary>
//        /// <param name="response">返回对象</param>
//        /// <returns></returns>
//        public static string BuilderXMLInfo(object obj)
//        {
//            return FormatXMLInfo(Services.ObjectToXML(obj));
//        }

//        public static string FormatXMLInfo(string xmlStr)
//        {
//            // 去掉<?xml version=\"1.0\" encoding=\"utf-8\"?>
//            if (string.IsNullOrEmpty(xmlStr))
//            {
//                return "";
//            }
//            else
//            {
//                // 如果有<?xml version=\"1.0\" encoding=\"utf-8\"?>，需要去掉
//                int intEnd = xmlStr.IndexOf("?>");
//                if (intEnd > -1)
//                {
//                    xmlStr = xmlStr.Replace(xmlStr.Remove(intEnd + 2), "");
//                }
//                return xmlStr;
//                //return xmlStr.Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?>", "").Replace("<?xml version=\"1.0\" encoding=\"utf-8\" ?>", "");
//            }
//        }

//        /// <summary>
//        /// 字符串写入到文件
//        /// </summary>
//        /// <param name="strInfo">文件内容</param>
//        /// <param name="fileName">文件路径</param>
//        /// <returns></returns>
//        public static bool StringToFile(string strInfo, string fileName)
//        {
//            StreamWriter writer = new StreamWriter(fileName);
//            try
//            {
//                writer.Write(strInfo);
//                writer.Flush();
//                writer.Close();
//                return true;
//            }
//            catch (Exception ex)
//            {
//                string xml = "<ErrorMessage><![CDATA[" + ex.ToString() + "]]></ErrorMessage>";
//                InterfaceLog.InterfaceERROR("字符串写入到文件出错！", ex);
//                return false;
//            }
//            finally
//            {
//                if (writer != null)
//                {
//                    writer.Close();
//                }
//            }
//        }

//        /// <summary>
//        /// 字符串写入到文件
//        /// </summary>
//        /// <param name="strInfo">文件内容</param>
//        /// <param name="fileName">文件路径</param>
//        /// <returns></returns>
//        public static bool StringToFileByEncoding(string strInfo, string fileName, string encodName)
//        {


//            try
//            {
//                using (FileStream fs = new FileStream(fileName, FileMode.Create))
//                {
//                    // 创建一个 StreamWriter 对象，使用 UTF-8 编码格式
//                    using (StreamWriter writer = new StreamWriter(fs, Encoding.GetEncoding(encodName)))
//                    {
//                        writer.Write(strInfo);
//                    }
//                }

//                return true;
//            }
//            catch (Exception ex)
//            {
//                string xml = "<ErrorMessage><![CDATA[" + ex.ToString() + "]]></ErrorMessage>";
//                InterfaceLog.InterfaceERROR("字符串写入到文件出错！", ex);
//                return false;
//            }

//        }

//        /**/

//        /// <summary>
//        /// 解压功能(解压压缩文件到指定目录)
//        /// </summary>
//        /// <param name="waitPath">待解压的文件</param>
//        /// <param name="outPath">指定解压目标目录</param>
//        public static void UnZip(string waitPath, string outPath)
//        {
//            if (!Directory.Exists(outPath))
//            {
//                Directory.CreateDirectory(outPath);
//            }
//            ZipInputStream s = new ZipInputStream(File.OpenRead(waitPath));

//            ZipEntry theEntry;
//            try
//            {
//                while ((theEntry = s.GetNextEntry()) != null)
//                {
//                    string fileName = System.IO.Path.GetFileName(theEntry.Name);

//                    if (fileName != String.Empty)
//                    {
//                        //解压文件
//                        FileStream streamWriter = File.Create(outPath + fileName);

//                        int size = 2048;
//                        byte[] data = new byte[2048];
//                        while (true)
//                        {
//                            size = s.Read(data, 0, data.Length);
//                            if (size > 0)
//                            {
//                                streamWriter.Write(data, 0, size);
//                            }
//                            else
//                            {

//                                streamWriter.Close();
//                                streamWriter.Dispose();
//                                break;
//                            }
//                        }

//                        streamWriter.Close();
//                        streamWriter.Dispose();
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                throw new Exception("解压文件出错：" + ex.Message);
//            }
//            finally
//            {
//                s.Close();
//                s.Dispose();
//            }
//        }

//        //解压缩Z格式的文件
//        public static void U7z(string file, string dir)
//        {
//            SevenZipCompressor.SetLibraryPath(AppDomain.CurrentDomain.BaseDirectory +
//                                              ConfigurationManager.AppSettings["7Z"]);
//            using (SevenZipExtractor sze = new SevenZipExtractor(file))
//            {
//                sze.ArchiveFileData.Count.ToString();

//                for (int i = 0; i < sze.ArchiveFileData.Count; i++)
//                {
//                    sze.ExtractFiles(dir, i);
//                }
//            }
//        }

//        /// <summary>
//        /// 发送邮件
//        /// </summary>
//        /// <param name="errorMsg"></param>
//        public static void SendSystemErrorEmailToSysMgr(string errorMsg)
//        {
//            try
//            {
//                string email = ADCSystemSettings.GetADCSystemSettings().EmailList;

//                if (!string.IsNullOrEmpty(email))
//                {
//                    Dictionary<string, string> dict = new Dictionary<string, string>();
//                    dict.Add("{@Time}", DateTime.Now.ToString());
//                    dict.Add("{@Message}", errorMsg);
//                    MessageTemplatInfo mailInfo = MessageTemplatBLL.GetMessageTemplat(57021, 2, "运营商", dict);

//                    Logger.LogDebug("发送邮件", "Common.Services", "发送邮件的日志记录",
//                                    "收件人:" + email + "内容：" + errorMsg);
//                    if (mailInfo.SendFlag == 1)
//                        // 发送邮件通知
//                        Notify.SendEmail(email.Split(';'),
//                                         mailInfo.Title,
//                                         mailInfo.Messasge, 1, NofityInfoFlag.GMCC, 0, "", "", -1, DateTime.Now);

//                }

//            }
//            catch (Exception ex)
//            {
//                throw new Exception("邮件发送出错;" + ex.Message);
//            }
//        }

//        #region 城市编码转换

//        /// <summary>
//        /// 城市转换编码
//        /// </summary>
//        /// <param name="areaName"></param>
//        /// <returns></returns>
//        public static string GetAreaCoe(string areaName)
//        {
//            string res = areaName;
//            switch (res.Trim())
//            {
//                case "全省":
//                    res = "GD";
//                    break;
//                case "广东":
//                    res = "GD";
//                    break;
//                case "广州":
//                    res = "GZ";
//                    break;
//                case "深圳":
//                    res = "SZ";
//                    break;
//                case "珠海":
//                    res = "ZH";
//                    break;
//                case "佛山":
//                    res = "FS";
//                    break;
//                case "汕头":
//                    res = "ST";
//                    break;
//                case "惠州":
//                    res = "HZ";
//                    break;
//                case "湛江":
//                    res = "ZJ";
//                    break;
//                case "江门":
//                    res = "JM";
//                    break;
//                case "肇庆":
//                    res = "ZQ";
//                    break;
//                case "韶关":
//                    res = "SG";
//                    break;
//                case "梅州":
//                    res = "MZ";
//                    break;
//                case "东莞":
//                    res = "DG";
//                    break;
//                case "中山":
//                    res = "ZS";
//                    break;
//                case "茂名":
//                    res = "MM";
//                    break;
//                case "汕尾":
//                    res = "SW";
//                    break;
//                case "潮州":
//                    res = "CZ";
//                    break;
//                case "揭阳":
//                    res = "JY";
//                    break;
//                case "阳江":
//                    res = "YJ";
//                    break;
//                case "清远":
//                    res = "QY";
//                    break;
//                case "河源":
//                    res = "HY";
//                    break;
//                case "云浮":
//                    res = "YF";
//                    break;
//            }
//            return res;
//        }

//        /// <summary>
//        /// 编码转换城市
//        /// </summary>
//        /// <param name="areaName"></param>
//        /// <returns></returns>
//        public static string GetAreaCnName(string areaCode)
//        {
//            string res = areaCode;
//            switch (res.Trim())
//            {
//                case "GZ":
//                    res = "广州";
//                    break;
//                case "SZ":
//                    res = "深圳";
//                    break;
//                case "ZH":
//                    res = "珠海";
//                    break;
//                case "FS":
//                    res = "佛山";
//                    break;
//                case "ST":
//                    res = "汕头";
//                    break;
//                case "HZ":
//                    res = "惠州";
//                    break;
//                case "ZJ":
//                    res = "湛江";
//                    break;
//                case "JM":
//                    res = "江门";
//                    break;
//                case "ZQ":
//                    res = "肇庆";
//                    break;
//                case "SG":
//                    res = "韶关";
//                    break;
//                case "MZ":
//                    res = "梅州";
//                    break;
//                case "DG":
//                    res = "东莞";
//                    break;
//                case "ZS":
//                    res = "中山";
//                    break;
//                case "茂名":
//                    res = "MM";
//                    break;
//                case "SW":
//                    res = "汕尾";
//                    break;
//                case "CZ":
//                    res = "潮州";
//                    break;
//                case "JY":
//                    res = "揭阳";
//                    break;
//                case "YJ":
//                    res = "阳江";
//                    break;
//                case "QY":
//                    res = "清远";
//                    break;
//                case "HY":
//                    res = "河源";
//                    break;
//                case "YF":
//                    res = "云浮";
//                    break;
//            }
//            return res;
//        }

//        /// <summary>
//        /// 地市英文编码转换数字编码
//        /// </summary>
//        /// <param name="areaCode"></param>
//        /// <returns></returns>
//        public static string GetAreaCode(string areaCode)
//        {
//            string res = areaCode;
//            switch (res.Trim())
//            {
//                case "广东":
//                    res = "GD";
//                    break;
//                case "GZ":
//                    res = "200";
//                    break;
//                case "SZ":
//                    res = "755";
//                    break;
//                case "ZH":
//                    res = "756";
//                    break;
//                case "FS":
//                    res = "757";
//                    break;
//                case "ST":
//                    res = "754";
//                    break;
//                case "HZ":
//                    res = "752";
//                    break;
//                case "ZJ":
//                    res = "759";
//                    break;
//                case "JM":
//                    res = "750";
//                    break;
//                case "ZQ":
//                    res = "758";
//                    break;
//                case "SG":
//                    res = "751";
//                    break;
//                case "MZ":
//                    res = "753";
//                    break;
//                case "DG":
//                    res = "769";
//                    break;
//                case "ZS":
//                    res = "760";
//                    break;
//                case "MM":
//                    res = "668";
//                    break;
//                case "SW":
//                    res = "660";
//                    break;
//                case "CZ":
//                    res = "768";
//                    break;
//                case "JY":
//                    res = "663";
//                    break;
//                case "YJ":
//                    res = "662";
//                    break;
//                case "QY":
//                    res = "763";
//                    break;
//                case "HY":
//                    res = "762";
//                    break;
//                case "YF":
//                    res = "766";
//                    break;
//            }
//            return res;
//        }

//        /// <summary>
//        /// 地市英文编码转换数字编码
//        /// </summary>
//        /// <param name="areaCode"></param>
//        /// <returns></returns>
//        public static string GetAreaCodeEn(string areaCode)
//        {
//            string res = areaCode;
//            switch (res.Trim())
//            {
//                case "200":
//                    res = "GZ";
//                    break;
//                case "755":
//                    res = "SZ";
//                    break;
//                case "756":
//                    res = "ZH";
//                    break;
//                case "757":
//                    res = "FS";
//                    break;
//                case "754":
//                    res = "ST";
//                    break;
//                case "752":
//                    res = "HZ";
//                    break;
//                case "759":
//                    res = "ZJ";
//                    break;
//                case "750":
//                    res = "JM";
//                    break;
//                case "758":
//                    res = "ZQ";
//                    break;
//                case "SG":
//                    res = "751";
//                    break;
//                case "753":
//                    res = "MZ";
//                    break;
//                case "769":
//                    res = "DG";
//                    break;
//                case "760":
//                    res = "ZS";
//                    break;
//                case "668":
//                    res = "MM";
//                    break;
//                case "660":
//                    res = "SW";
//                    break;
//                case "768":
//                    res = "CZ";
//                    break;
//                case "663":
//                    res = "JY";
//                    break;
//                case "662":
//                    res = "YJ";
//                    break;
//                case "763":
//                    res = "QY";
//                    break;
//                case "762":
//                    res = "HY";
//                    break;
//                case "766":
//                    res = "YF";
//                    break;
//            }
//            return res;
//        }

//        #endregion

//        /// <summary>
//        /// XSD报文验证
//        /// </summary>
//        /// <param name="requestXML">请求报文主体</param>
//        public static void ValidRequestXML(object requestXML, string types)
//        {
//            XMLValidator validator = new XMLValidator();
//            validator.Validate(requestXML, types);
//            if (!validator.ValidateResult)
//            {
//                throw new Exception("XSD验证结果：" + validator.ErrorMsg);
//            }
//        }

//        /// <summary>
//        /// 将对象转换成XML
//        /// </summary>
//        /// <param name="provBOSS"></param>
//        /// <returns></returns>
//        public static string FormatRequestProvBossToXml(object provBOSS)
//        {
//            string xmlStr = ObjectToXML(provBOSS);
//            //格式化字符串
//            xmlStr = SIMonitorXmlFormat(xmlStr);
//            xmlStr = Format(xmlStr);

//            return xmlStr;
//        }

//        /// <summary>
//        /// 校验地区编码
//        /// </summary>
//        /// <param name="region"></param>
//        /// <returns></returns>
//        public static bool CheckRegion(string region)
//        {

//            bool arc = false;
//            System.Text.RegularExpressions.Regex r = new System.Text.RegularExpressions.Regex(@"^[0-9]*[1-9][0-9]*$");
//            //如果不是数字，且长度为2
//            if (!r.IsMatch(region) && region.Length == 2)
//            {
//                if (!string.IsNullOrEmpty(SYSequenceDAL.GetAreaCodeByAreaToken(region).ToString()))
//                {
//                    arc = true;
//                }
//            }
//            //如果是数字，且长度为3
//            if (r.IsMatch(region) && region.Length == 3)
//            {
//                if (!string.IsNullOrEmpty(SYSequenceDAL.GetAreaTokenByAreaCode(region).ToString()))
//                {
//                    arc = true;
//                }
//            }
//            return arc;
//        }

//        /// <summary>
//        /// 是否跳转NGESOP接口
//        /// </summary>
//        /// <param name="areaCode">地市编码,英文</param>
//        /// <param name="interFaceCode">接口编码</param>
//        /// <returns></returns>
//        public static bool IsToNGESOPInterface(string areaCode, string interFaceCode)
//        {
//            try
//            {
//                //获取运营商地市配置
//                string pilotAreaCode = ADCSystemSettings.GetADCSystemSettings().PilotAreaCode;
//                if (string.IsNullOrEmpty(pilotAreaCode)) return false;
//                //转码英文地市为数字
//                string codes = GetAreaCode(areaCode);
//                var pwdList = pilotAreaCode.Split(new string[] {","}, StringSplitOptions.RemoveEmptyEntries);
//                //匹配是否试点地市
//                if (pwdList.Any(s => s.Equals(codes)))
//                {
//                    //获取接口编码
//                    const string isCallNgesopInterface =
//                        "SSM0001;SSM0002;SSM0003;SSM0004;SSM0005;SSM0008;SSM0010;SSM0012;AOM0001;AOM0002;AOM0003;AOM0004;AOM0006";
//                    var isCallNgesopInterfaceList = isCallNgesopInterface.Split(new string[] {";"},
//                                                                                StringSplitOptions.RemoveEmptyEntries);
//                    //判断是否是需要跳转NGESOP的接口
//                    if (isCallNgesopInterfaceList.Any(s => s.Equals(interFaceCode.ToUpper())))
//                    {
//                        return true;
//                    }
//                }

//            }
//            catch (Exception ex)
//            {
//                InterfaceLog.InterfaceERROR("NGESOP接口跳转功能,异常", ex);
//            }
//            return false;
//        }

//        /// <summary>
//        /// 生成压缩文件
//        /// </summary>
//        /// <param name="strZipPath">生成的zip文件的路径</param>
//        /// <param name="strZipTopDirectoryPath">源文件的上级目录</param>
//        /// <param name="intZipLevel">T压缩等级</param>
//        /// <param name="strPassword">压缩包解压密码</param>
//        /// <param name="filesOrDirectoriesPaths">源文件路径</param>
//        /// <returns></returns>
//        public static bool Zip(string strZipPath, string strZipTopDirectoryPath, int intZipLevel, string strPassword,
//                         string[] filesOrDirectoriesPaths)
//        {
//            try
//            {
//                List<string> AllFilesPath = new List<string>();
//                if (filesOrDirectoriesPaths.Length > 0) // get all files path
//                {
//                    for (int i = 0; i < filesOrDirectoriesPaths.Length; i++)
//                    {
//                        if (File.Exists(filesOrDirectoriesPaths[i]))
//                        {
//                            AllFilesPath.Add(filesOrDirectoriesPaths[i]);
//                        }
//                        else if (Directory.Exists(filesOrDirectoriesPaths[i]))
//                        {
//                            GetDirectoryFiles(filesOrDirectoriesPaths[i], AllFilesPath);
//                        }
//                    }
//                }

//                if (AllFilesPath.Count > 0)
//                {

//                    using (ZipOutputStream zipOutputStream = new ZipOutputStream(File.Create(strZipPath)))
//                    {
//                        zipOutputStream.SetLevel(intZipLevel);
//                        zipOutputStream.Password = strPassword;

//                        for (int i = 0; i < AllFilesPath.Count; i++)
//                        {
//                            string strFile = AllFilesPath[i].ToString();
//                            try
//                            {
//                                if (strFile.Substring(strFile.Length - 1) == "") //folder
//                                {
//                                    string strFileName = strFile.Replace(strZipTopDirectoryPath, "");
//                                    if (strFileName.StartsWith(""))
//                                    {
//                                        strFileName = strFileName.Substring(1);
//                                    }
//                                    ZipEntry entry = new ZipEntry(strFileName);
//                                    entry.DateTime = DateTime.Now;
//                                    zipOutputStream.PutNextEntry(entry);
//                                }
//                                else //file
//                                {
//                                    FileStream fs = File.OpenRead(strFile);

//                                    byte[] buffer = new byte[fs.Length];
//                                    fs.Read(buffer, 0, buffer.Length);

//                                    string strFileName = strFile.Replace(strZipTopDirectoryPath, "");
//                                    if (strFileName.StartsWith(""))
//                                    {
//                                        strFileName = strFileName.Substring(0);
//                                    }
//                                    ZipEntry entry = new ZipEntry(strFileName);
//                                    entry.DateTime = DateTime.Now;
//                                    zipOutputStream.PutNextEntry(entry);
//                                    zipOutputStream.Write(buffer, 0, buffer.Length);

//                                    fs.Close();
//                                    fs.Dispose();
//                                }
//                            }
//                            catch
//                            {
//                                continue;
//                            }
//                        }

//                        zipOutputStream.Finish();
//                        zipOutputStream.Close();

//                        return true;
//                    }
//                }
//                else
//                {
//                    return false;
//                }
//            }
//            catch
//            {
//                return false;
//            }
//        }

//        /// <summary>
//        /// Gets the directory files.
//        /// </summary>
//        /// <param name="strParentDirectoryPath">源文件路径</param>
//        /// <param name="AllFilesPath">所有文件路径</param>
//        private static void GetDirectoryFiles(string strParentDirectoryPath, List<string> AllFilesPath)
//        {
//            string[] files = Directory.GetFiles(strParentDirectoryPath);
//            for (int i = 0; i < files.Length; i++)
//            {
//                AllFilesPath.Add(files[i]);
//            }
//            string[] directorys = Directory.GetDirectories(strParentDirectoryPath);
//            for (int i = 0; i < directorys.Length; i++)
//            {
//                GetDirectoryFiles(directorys[i], AllFilesPath);
//            }
//            if (files.Length == 0 && directorys.Length == 0) //empty folder
//            {
//                AllFilesPath.Add(strParentDirectoryPath);
//            }
//        }

//    }
//}